import Cocoa

//var str = "Hello, playground"


/**
 1.区间运算符
  1> 闭区间运算符
  2> 半开半闭区间运算符
  3> 倒序索引
  4> 单侧区间
  5> 区间运算符可以作用在数组,也可以作用在字符串
2.位运算符
  1> 位取反运算符 ( ~ ）
  2>
 
 */


//闭区间运算符
//for i in 1...5 {
//    print(i)
//}

//半开半闭区间运算符
//for i in 1..<5 {  //取不到5
//    print(i)
//}

//区间运算符可以作用在数组,也可以作用在字符串,还可以使用倒序
//let names = ["张三", "李四", "王五", "赵柳"]
//for name in names[2...] {
//    print(name)
//}

//倒序索引   reversed:颠倒的,相反的
//for i in (0...10).reversed() {
//    print(i)
//}


//单侧区间
//let range = ...5   //无穷到5
////判断range是否包含7
//print(range.contains(7))
////判断range是否可以包含5
//print(range.contains(5))
//print(range.contains(-1))

//区间运算符可以作用在comparable类型上,返回闭区间和半闭区间
//var str = "hello,world"
//let interval = "a"..."z"
//for char in str {
//    if !interval.contains(String(char)) {  //String(char):将subString转换成String
//        print("\(char)不是小写字母")
//    }
//}

//区间运算符作用在字符串
//var str = "hello,world"
//let range2 = str.index(str.endIndex, offsetBy: -6)..<str.endIndex
//print(str[range2])
//str.removeSubrange(range2)
//print("str is \(str)")


/**
 运算符分为一元、二元和三元运算符:
 
 一元运算符对单一操作对象操作（如 -a）。一元运算符分前置运算符和后置运算符，前置运算符需紧跟在操作对象之前（如 !b），后置运算符需紧跟在操作对象之后（如 c!）。
 二元运算符操作两个操作对象（如 2 + 3），是中置的，因为它们出现在两个操作对象之间。
 三元运算符操作三个操作对象，和 C 语言一样，Swift 只有一个三元运算符，就是三目运算符（a ? b : c）。
 受运算符影响的值叫操作数，在表达式 1 + 2 中，加号 + 是二元运算符，它的两个操作数是值 1 和 2。
 */

//赋值运算符

//赋值运算符（a = b），表示用 b 的值来初始化或更新 a 的值：
//let b = 10
//var a = 5
//a = b  //a现在等于10
//
//var (x, y) = (1, 2)
// 现在 x 等于 1，y 等于 2

//与 C 语言和 Objective-C 不同，Swift 的赋值操作并不返回任何值。所以下面语句是无效的：
//if x = y {
//    // 此句错误，因为 x = y 并不返回任何值
//}

//算术运算符
//
//Swift 中所有数值类型都支持了基本的四则算术运算符：
//
//加法（+）
//减法（-）
//乘法（*）
//除法（/）
1 + 2       // 等于 3
5 - 3       // 等于 2
2 * 3       // 等于 6
10.0 / 2.5  // 等于 4.0

//加法运算符也可用于 String 的拼接：
"hello, " + "world"  // 等于 "hello, world"

//求余运算符
//求余运算符（a % b）是计算 b的多少倍刚刚好可以容入 a，返回多出来的那部分（余数）。
//计算 9 % 4，你先计算出 4 的多少倍会刚好可以容入 9 中：
9 % 4    // 等于 1
//为了得到a % b 的结果，% 计算了以下等式，并输出 余数作为结果：
//a = (b × 倍数) + 余数
//同样的方法，我们来计算 -9 % 4：
-9 % 4   // 等于 -1
//在对负数 b 求余时，b 的符号会被忽略。这意味着 a % b 和 a % -b 的结果是相同的。



//一元负号运算符
//一元负号符（-）写在操作数之前，中间没有空格。
let three = 3
let minusThree = -three       // minusThree 等于 -3
let plusThree = -minusThree   // plusThree 等于 3, 或 "负负3"

//一元正号运算符
//一元正号符（+）不做任何改变地返回操作数的值

//组合赋值运算符
//表达式 a += 2 是 a = a + 2 的简写，一个组合加运算就是把加法运算和赋值运算组合成进一个运算符里，同时完成两个运算任务。
//var a = 1
//a += 2
// a 现在是 3

//注意:复合赋值运算没有返回值，let b = a += 2 这类代码是错误。这不同于上面提到的自增和自减运算符。



//比较运算符
//Swift 支持以下的比较运算符：
//等于（a == b）
//不等于（a != b）
//大于（a > b）
//小于（a < b）
//大于等于（a >= b）
//小于等于（a <= b）
//每个比较运算都返回了一个标识表达式是否成立的布尔值：
1 == 1   // true, 因为 1 等于 1
2 != 1   // true, 因为 2 不等于 1
2 > 1    // true, 因为 2 大于 1
1 < 2    // true, 因为 1 小于2
1 >= 1   // true, 因为 1 大于等于 1
2 <= 1   // false, 因为 2 并不小于等于 1

//比较运算多用于条件语句，如 if 条件：
let name = "world"
if name == "world" {
    print("hello, world")
} else {
    print("I'm sorry \(name), but I don't recognize you")
}
// 输出“hello, world", 因为 `name` 就是等于 "world”

//如果两个元组的元素相同，且长度相同的话，元组就可以被比较。比较元组大小会按照从左到右、逐值比较的方式，直到发现有两个值不等时停止。如果所有的值都相等，那么这一对元组我们就称它们是相等的。例如：
(1, "zebra") < (2, "apple")   // true，因为 1 小于 2
(3, "apple") < (3, "bird")    // true，因为 3 等于 3，但是 apple 小于 bird
(4, "dog") == (4, "dog")      // true，因为 4 等于 4，dog 等于 dog

//注意: Swift 标准库只能比较七个以内元素的元组比较函数。如果你的元组元素超过七个时，你需要自己实现比较运算符

//三元运算符
//三元运算符的特殊在于它是有三个操作数的运算符，它的形式是 问题 ? 答案 1 : 答案 2。它简洁地表达根据 问题成立与否作出二选一的操作。如果 问题 成立，返回 答案 1 的结果；反之返回 答案 2的结果。

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)
// rowHeight 现在是 90

//三元运算符是以下代码的缩写形式：
//if question {
//    answer1
//} else {
//    answer2
//}


//空合运算符
//空合运算符（a ?? b）将对可选类型 a 进行空判断，如果 a 包含一个值就进行解包，否则就返回一个默认值b。表达式 a必须是Optional 类型。默认值 b 的类型必须要和 a 存储值的类型保持一致。
//空合运算符是对以下代码的简短表达方法：
//a != nil ? a! : b

//上述代码使用了三元运算符。当可选类型 a的值不为空时，进行强制解包（a!），访问 a 中的值；反之返回默认值 b。无疑空合运算符（??）提供了一种更为优雅的方式去封装条件判断和解包两种行为，显得简洁以及更具可读性。

//注意: 如果 a为非空值（non-nil），那么值b 将不会被计算。这也就是所谓的短路求值。

//下文例子采用空合运算符，实现了在默认颜色名和可选自定义颜色名之间抉择：
let defaultColorName = "red"
var userDefinedColorName: String?   //默认值为 nil

var colorNameToUse = userDefinedColorName ?? defaultColorName
// userDefinedColorName 的值为空，所以 colorNameToUse 的值为 "red"

//
//逻辑运算符
//逻辑运算符的操作对象是逻辑布尔值。Swift 支持基于 C 语言的三个标准逻辑运算。
//逻辑非（!a）
//逻辑与（a && b）
//逻辑或（a || b）

//逻辑非运算符
//逻辑非运算符（!a）对一个布尔值取反，使得 true 变 false，false 变 true。
//它是一个前置运算符，需紧跟在操作数之前，且不加空格。读作 非 a ，例子如下：
let allowedEntry = false
if !allowedEntry {
    print("ACCESS DENIED")
}
// 输出“ACCESS DENIED”

//逻辑与运算符
//逻辑与运算符（a && b）表达了只有 a 和 b 的值都为 true 时，整个表达式的值才会是 true。
let enteredDoorCode = true
let passedRetinaScan = false
if enteredDoorCode && passedRetinaScan {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出“ACCESS DENIED”

//逻辑或运算符
//逻辑或运算符（a || b）是一个由两个连续的 | 组成的中置运算符。它表示了两个逻辑表达式的其中一个为 true，整个表达式就为 true
let hasDoorKey = false
let knowsOverridePassword = true
if hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出“Welcome!”

//逻辑运算符组合计算
if enteredDoorCode && passedRetinaScan || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出“Welcome!”

//注意: Swift 逻辑操作符 && 和 || 是左结合的，这意味着拥有多元逻辑操作符的复合表达式优先计算最左边的子表达式。


//使用括号来明确优先级
if (enteredDoorCode && passedRetinaScan) || hasDoorKey || knowsOverridePassword {
    print("Welcome!")
} else {
    print("ACCESS DENIED")
}
// 输出“Welcome!”

//这括号使得前两个值被看成整个逻辑表达中独立的一个部分。虽然有括号和没括号的输出结果是一样的，但对于读代码的人来说有括号的代码更清晰。可读性比简洁性更重要，请在可以让你代码变清晰的地方加个括号吧！




//位运算符
//1. 位取反运算符(~):是对所有位的数字进行取反操作,按位取反“~”：按位取反1变0，0变1
let a: UInt8 = 255
print(~a)
//2. 位与运算符（&）:可以对两个数的比特位进行合并。它会返回一个新的数，只有当这两个数都是 1 的时候才能返回 1
print(a & 1)
//4. 位异或运算符（^）:或者说“互斥或”（^）可以对两个数的比特位进行比较。它返回一个新的数，当两个操作数的对应位不相同时，该数的对应位就为1。
//print(a ^ 3)
//3. 位或运算符（|）
//位或运算符（|）可以对两个比特位进行比较，然后返回一个新的数，只要两个操作位任意一个为 1 时，那么对应的位数就为 1 。
//print(a | 1)
//5. 位左移和右移运算符:位左移运算符（ << ）和位右移运算符（>> ）可以把所有位数的数字向左或向右移动一个确定的位数。
//位左移和右移具有给整数乘以或除以二的效果。将一个数左移一位相当于把这个数翻倍，将一个数右移一位相当于把这个数减半。
//let b: UInt8 = 8
//print(b ^ 1)
//print(b << 3);
//print(b >> 2)

//144的二进制左移3位，前面(高位)去000（3个0），后面(低位)补000（3个0）。低位补0
//从 10010000 -> 10010000000 转换成十进制答案就是:1152

//另一种快捷算法:  左移运算符：num << n ,相当于num乘以2的n次方
print(144<<3)  //这里就是144乘以2的3次方:就是1152
//144的二进制右移3位，前面(高位)补000（3个0），后面(低位)去000（3个0）。低位补0
//从 10010000 -> 00010010  转换成十进制是: 18
// 另一种快捷算法:  右移运算符：num >> n ,相当于num除以2的n次方
print(144>>3)  //这里就是144除以2的3次方:就是18

//6. 无符号整数的移位操作
//已经存在的比特位按指定的位数进行左移和右移
//任何移动超出整型存储边界的位都会被丢弃
//用 0 来填充向左或向右移动后产生的空白位




//7. 有符号整数的移位操作
//有符号整数使用它的第一位（所谓的符号位）来表示这个整数是正数还是负数。符号位为 0 表示为正数，1 表示为负数。
//其余的位数（所谓的数值位）存储了实际的值。有符号正整数和无符号数的存储方式是一样的，都是从 0 开始算起。
//但是负数的存储方式略有不同。它存储的是 2的n次方减去它的绝对值，这里的 n为数值位的位数。



//运算符重载:类和结构体可以为现有的运算符提供自定义的实现
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//var vector1 = Vector2D(x: 3.0, y: 1.0)
//var vector2 = Vector2D(x: 2.0, y: 4.0)
//var newVector = Vector2D(x: vector1.x + vector2.x, y: vector1.y + vector2.y)
//print(newVector)  //这样写的代码比较臃肿,复用率不高

//使用运算符重载
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//extension Vector2D {
//    static func + (left: Vector2D, right: Vector2D) -> Vector2D {
//        return Vector2D (x: left.x + right.x, y: left.y + right.y)
//    }
//}
//var vector1 = Vector2D(x: 3.0, y: 1.0)
//var vector2 = Vector2D(x: 2.0, y: 4.0)
//var newVector = vector1 + vector2
//print(newVector)


//一元运算符重载:类与结构体也能实现标准一元运算符的重载,要实现前缀或者后缀运算符,需要在声明运算符能函数的时候在func关键字之前指定prefix或者postfix限定符
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//extension Vector2D {
//    static prefix func - (vector: Vector2D) -> Vector2D {
//        return Vector2D(x: -vector.x, y: -vector.y)
//    }
//}
//var vector1 = Vector2D(x: 2.0, y: 3.0)
//var newVector = -vector1
//print("x is \(newVector.x), y is \(newVector.y)")


//组合赋值运算符重载(+=  -=)
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//extension Vector2D {
//    static func += (left: Vector2D, right: Vector2D) -> Vector2D {
//        return Vector2D(x: left.x + right.x, y: left.y + right.y)
//    }
//}
//var vector1 = Vector2D(x: 2.0, y: 3.0)
//var vector2 = Vector2D(x: 6.0, y: 1.0)
//vector1 += vector2

//等价运算符重载,自定义的类和结构体不接收等价运算符的默认实现"=="和"!=",要使用等加运算符来判断你自己定义的类型,需要和其他中缀运算符一样提供一个等价运算符重载,并且遵守标准库的Equatable协议
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//extension Vector2D: Equatable {
//    static func == (left: Vector2D, right: Vector2D) -> Bool {
//        return left.x == right.x && left.y == right.y
//    }
//}
//var vector1 = Vector2D(x: 2.0, y: 4.0)
//var vector2 = Vector2D(x: 2.0, y: 4.0)
//print(vector1 == vector2)


//自定义运算符   prefix:前缀  infix:中缀    postfix:后缀
//struct Vector2D {
//    var x = 0.0, y = 0.0
//}
//prefix operator +++
//extension Vector2D {
//    static prefix func +++ (vector: inout Vector2D) -> Vector2D {
//        vector = Vector2D(x: vector.x + vector.x, y: vector.y + vector.y)
//        return vector
//    }
//}
//var vector1 = Vector2D(x: 1.0, y: 3.0)
//let newVector = +++vector1
//print(newVector)


struct Vector2D {
    var x = 0.0, y = 0.0
}
//自定义运算符的优先级
infix operator +-: AdditionPrecedence
extension Vector2D {
    static func +- (left: inout Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y - right.y)
    }
}

infix operator *^: MyPrecedence
//改变现有的运算符优先级
precedencegroup MyPrecedence {
    associativity: left  //none代表没有结核性
    higherThan: AdditionPrecedence   //高于优先级
   // lowerThan: AdditionPrecedence
    assignment: true
}
extension Vector2D {
    static func *^ (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x * right.x, y: left.y * left.y + right.y * right.y)
    }
}


var vector1 = Vector2D(x: 2.0, y: 6.0)
var vector2 = Vector2D(x: 3.0, y: 4.0)
var vector3 = Vector2D(x: 2.0, y: 4.0)
let newVector = vector1 +- vector2 *^ vector3  //先算*^再算+-
print(newVector)



